const { Schema } = require('koishi')

/**
 * @description 剑网三角色查询插件
 */
class Jx3RolePlugin {
  /**
   * @param {object} ctx - Koishi上下文
   * @param {object} config - 插件配置 
   */
  constructor(ctx, config) {
    this.ctx = ctx
    this.config = config
    
    // 获取API服务
    this.jx3Api = ctx.jx3Api
    if (!this.jx3Api) {
      throw new Error('请先安装并配置jx3-api插件')
    }
    
    this.registerCommands()
  }

  /**
   * @description 注册命令
   */
  registerCommands() {
    const { ctx } = this
    
    // 查询角色基本信息
    ctx.command('jx3.角色 <角色名>', '查询角色的基本信息')
      .option('server', '-s <server:string> 服务器名称', { fallback: this.config.defaultServer })
      .action(async ({ session, options }, roleName) => {
        if (!roleName) return '请输入角色名'
        
        try {
          const roleInfo = await this.jx3Api.getRoleInfo(roleName, options.server)
          return this.formatRoleInfo(roleInfo)
        } catch (error) {
          ctx.logger.error('查询角色信息失败:', error)
          return `查询失败: ${error.message}`
        }
      })
    
    // 查询角色装备
    ctx.command('jx3.装备 <角色名>', '查询角色的装备信息')
      .option('server', '-s <server:string> 服务器名称', { fallback: this.config.defaultServer })
      .action(async ({ session, options }, roleName) => {
        if (!roleName) return '请输入角色名'
        
        try {
          const equipInfo = await this.jx3Api.getRoleEquip(roleName, options.server)
          return this.formatEquipInfo(equipInfo)
        } catch (error) {
          ctx.logger.error('查询角色装备失败:', error)
          return `查询失败: ${error.message}`
        }
      })
    
    // 绑定角色
    ctx.command('jx3.绑定角色 <角色名>', '绑定自己的剑网三角色')
      .option('server', '-s <server:string> 服务器名称', { fallback: this.config.defaultServer })
      .action(async ({ session, options }, roleName) => {
        if (!roleName) return '请输入角色名'
        if (!session.userId) return '无法识别您的用户ID'
        
        try {
          // 检查角色是否存在
          await this.jx3Api.getRoleInfo(roleName, options.server)
          
          // 保存绑定信息
          await ctx.database.set('jx3_user_bind', { userId: session.userId }, {
            roleName,
            server: options.server,
            updatedAt: Date.now()
          })
          
          return `已成功绑定角色 ${roleName}@${options.server}`
        } catch (error) {
          ctx.logger.error('绑定角色失败:', error)
          return `绑定失败: ${error.message}`
        }
      })
    
    // 我的角色信息
    ctx.command('jx3.我的角色', '查询自己绑定的角色信息')
      .action(async ({ session }) => {
        if (!session.userId) return '无法识别您的用户ID'
        
        try {
          // 查询绑定信息
          const bind = await ctx.database.get('jx3_user_bind', { userId: session.userId })
          if (!bind || bind.length === 0) {
            return '您尚未绑定角色，请使用 jx3.绑定角色 <角色名> 进行绑定'
          }
          
          const userBind = bind[0]
          const roleInfo = await this.jx3Api.getRoleInfo(userBind.roleName, userBind.server)
          return this.formatRoleInfo(roleInfo)
        } catch (error) {
          ctx.logger.error('查询绑定角色失败:', error)
          return `查询失败: ${error.message}`
        }
      })
  }

  /**
   * @description 格式化角色信息
   * @param {object} roleInfo - 角色信息
   * @returns {string} 格式化后的角色信息
   */
  formatRoleInfo(roleInfo) {
    const { name, server, level, sect, camp, prestige, roleId, appearance } = roleInfo
    
    return `角色信息：
【名称】${name}
【服务器】${server}
【等级】${level}
【门派】${sect}
【阵营】${camp}
【声望】${prestige}
【ID】${roleId}
`
  }

  /**
   * @description 格式化装备信息
   * @param {object} equipInfo - 装备信息
   * @returns {string} 格式化后的装备信息
   */
  formatEquipInfo(equipInfo) {
    const { name, server, equipScore, equips } = equipInfo
    
    let equipText = `${name}@${server} 的装备信息：
【装分】${equipScore}

`
    
    equips.forEach(equip => {
      equipText += `【${equip.position}】${equip.name} (品质:${equip.quality})
`
    })
    
    return equipText
  }
}

// 定义数据库模型
function applyModel(ctx) {
  // 用户角色绑定
  ctx.model.extend('jx3_user_bind', {
    userId: 'string',
    roleName: 'string',
    server: 'string',
    updatedAt: 'number'
  })
}

// 配置模式定义
const configSchema = Schema.object({
  defaultServer: Schema.string().default('梦江南')
})

// 插件主方法
module.exports.name = 'jx3-role'
module.exports.inject = ['database', 'jx3Api']

module.exports.Config = configSchema

module.exports.apply = (ctx, config) => {
  // 应用数据库模型
  applyModel(ctx)
  
  // 创建插件实例
  ctx.plugin(Jx3RolePlugin, config)
  
  ctx.on('ready', () => {
    ctx.logger.info('剑网三角色查询插件已启动')
  })
} 